<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Chapter&nbsp;16.&nbsp;jBPM 流程定义语言 (JPDL)</title>
    <link rel="stylesheet" href="css/html.css" type="text/css">
    <meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
    <link rel="home" href="index.html" title="JBoss jBPM 3.1">
    <link rel="up" href="index.html" title="JBoss jBPM 3.1">
    <link rel="previous" href="logging.html" title="Chapter&nbsp;15.&nbsp;Logging">
    <link rel="next" href="security.html" title="Chapter&nbsp;17.&nbsp;Security">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="navheader">
    <table width="100%" summary="Navigation header">
        <tr>
            <th colspan="3" align="center">Chapter&nbsp;16.&nbsp;jBPM 流程定义语言 (JPDL)</th>
        </tr>
        <tr>
            <td width="20%" align="left"><a accesskey="p" href="logging.html">Prev</a>&nbsp;</td>
            <th width="60%" align="center">&nbsp;</th>
            <td width="20%" align="right">&nbsp;<a accesskey="n" href="security.html">Next</a></td>
        </tr>
    </table>
    <hr>
</div>
<div class="chapter" lang="cn">
<div class="titlepage">
    <div>
        <div><h2 class="title"><a name="jpdl"></a>Chapter&nbsp;16.&nbsp;jBPM 流程定义语言 (JPDL)</h2>
        </div>
    </div>
    <div></div>
</div>
<p>JPDL指定了一个xml模式以及把所有这些相关的流程定义文件打包到一个流程打包文件的机制。
</p>

<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="theprocessarchive"></a>16.1.&nbsp;流程打包文件
            </h2></div>
        </div>
        <div></div>
    </div>
    <p>流程打包文件是一个zip文件。流程打包文件以<tt class="literal">processdefinition.xml</tt>文件为中心。
        该文件中的主要信息是流程图的定义，同时也包含关于动作和任务的信息。流程打包文件还可以包含其他流程相关的文件
        如类、ui-forms和任务等。
    </p>

    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="deployingaprocessarchive"></a>16.1.1.&nbsp;部署流程打包文件
                </h3></div>
            </div>
            <div></div>
        </div>
        <p> 可以通过3种方式来部署流程打包文件：用流程设计工具，用一个ant任务，或者编程来实现。
        </p>

        <p> 用流程设计工具来部署流程打包文件的功能仍在开发当中。
        </p>

        <p>用ant任务来部署流程打包文件可以按如下步骤来做：
        </p><pre class="programlisting">&lt;target name="deploy.par"&gt;
  &lt;taskdef name="deploypar" classname="org.jbpm.ant.DeployParTask"&gt;
    &lt;classpath --make sure the jbpm-[version].jar is in this classpath--/&gt;  
  &lt;/taskdef&gt;  
  &lt;deploypar par="build/myprocess.par" /&gt; 
&lt;/target&gt;</pre>
        <p> 如果要同时部署多个流程包，可以内嵌使用fileset元素。file属性本身是可选的。该ant任务的其他可选属性是：</p>

        <div class="itemizedlist">
            <ul type="disc">
                <li><span class="bold"><b>cfg</b></span>: cfg 是可选的，它的缺省值是'hibernate.cfg.xml'。
                    这个hibernate配置文件包含数据库jdbc连接属性映射文件。
                </li>
                <li><span class="bold"><b>properties</b></span>: properties 是可选的，它会重写所有hibernate.cfg.xml
                    中的hibernate配置属性。
                </li>
                <li><span class="bold"><b>createschema</b></span>: 如果为true，在流程包被部署前会创建数据库表。
                </li>
            </ul>
        </div>
        <p>流程包还可以用类<tt class="literal">org.jbpm.jpdl.par.ProcessArchiveDeployer</tt>
    来进行程序化部署。</p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="processversioning"></a>16.1.2.&nbsp;流程版本控制（Process versioning）</h3></div>
            </div>
            <div></div>
        </div>
        <p> 流程定于永远不该被改变，因为极难（如果不是，就是不可能）预知所有可能发生的影响。</p>

        <p> 为了避开这个问题，jBPM有一个精巧的流程版本控制机制。这种机制允许多个同名的流程定义共存在数据库中。
            流程实例可以从当时可用的最新版本开始，并在整个生命周期内保持在该版本的流程定义上运行。当流程的一个
            新版本部署后，新的流程实例在新版本上开始，老的流程实例则仍然在老版本的流程上执行。
        </p>

        <p> 流程定义是由流程图描述和相关的java类组成的（后者为可选部分）。这些java类在运行时间可以通过两种方
            式被jBPM使用：通过确认这些类对jBPM的类载入器是可见的。这常常意味着你可以把你的委托类放在一个<tt class="literal">.jar</tt>
            文件中，并把该文件和<tt class="literal">jbpm-[version].jar</tt>放在一起。java类也可以包含在
            流程包里。当你包含你的委托类在流程包里的时候（他们对jBPM类载入器不可见），jBPM仍然对这些类应用版本
            管理。关于流程类载入的更多信息可以看看<a href="jpdl.html#delegation" title="16.2.&nbsp;Delegation">Section&nbsp;16.2, &#8220;Delegation&#8221;</a>
        </p>

        <p> 当一个流程包被部署的时候，会在jBPM的数据库中创建一个流程定义。流程定义可以基于流程定义名称来进行版
            本管理。当一个命名的流程包被部署的时候，同时会被分配一个版本号。流程部署器会寻找同名流程定义的最高
            版本号，然后加1赋给当前部署的流程。无名流程定义的版本号永远是-1。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="changingdeployedprocessdefinitions"></a>16.1.3.&nbsp;改变已经部署的流程定义</h3></div>
            </div>
            <div></div>
        </div>
        <p> 流程定义部署到jBPM数据库后再去改变它可能会遇到很多潜在的危险。因此，这是非常不鼓励的。
        </p>

        <p> 实际上，对流程定义可能作出的改变很多，其中一些是无害的，但是有些改变会牵连其他部分，结果可能与期望极不相符。
        </p>

        <p>所以，请考虑通过这种方法 <a href="jpdl.html#migratingprocessinstances"
                                 title="16.1.4.&nbsp;迁移流程实例">迁移流程实例</a>
            到一个新的流程定义。
        </p>

        <p>当你要考虑这些的时候，有如下几点：
        </p>

        <p><span class="bold"><b>使用 hibernate 的 update</b></span>: 你可以只是用hibernate的session来载入流程定义
            ，修改它，然后保存。hibernate的session可以通过 <tt class="literal">JbpmContext.getSession()</tt>方法获得.
        </p>

        <p><span class="bold"><b>二级缓存</b></span>: 在你更新了一个存在流程的定义后，你要把该流程的定义从二级缓存中去掉。请看
            <a href="persistence.html#secondlevelcache" title="7.10.&nbsp;Second level cache">Section&nbsp;7.10,
            &#8220;二级缓存&#8221;</a>
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="migratingprocessinstances"></a>16.1.4.&nbsp;迁移流程实例（Migrating process instances）
                </h3></div>
            </div>
            <div></div>
        </div>
        <p>一种改变流程定义的替代方法可能是把流程执行转换到一个新的流程定义上。由于业务流程的长效性，做这件事情并不显得琐碎。
            目前，这还是一个实验性的领域，所以还未能提供太多的支持。
        </p>

        <p>正如你说知道的，流程定义数据，流程实例数据（运行时数据）和日志数据很明显是不同的。通过这种途径，你创建一个分离的
            新的流程定义到jBPM数据库中（例如，部署相同流程的一个新版本）。然后运行时信息被转换到新的流程定义上。这可能引起
            造成转换时把老流程中指向一个节点的令牌指向新流程中一个被删除了的节点。所以只有新的数据在数据库里创建了，但是一个
            执行被分成两个并指向两个不同的流程实例对象。对于工具和统计，这可能会变得更加棘手。当资源允许的时候，我们将会在
            这一块增加支持。例如，一个指针可以从一个流程实例添加到它的祖先。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="processconversion"></a>16.1.5.&nbsp;流程转换</h3></div>
            </div>
            <div></div>
        </div>
        <p> 已经有一个转换类可以帮助你把jBPM 2.0的流程包转换成jBPM 3.0兼容的流程包。创建一个输出目录来放置这些转换后的
            流程包。然后从jBPM 3.0分发包的build目录中输入这个命令：</p>

        <p>java -jar converter.jar indirectory outdirectory</p>

        <p> 用你的jBPM 2.0的流程包所在的目录来替换"indirectory"作为输入目录。用你创建来放置转换后的流程包的目录来替换
            "outdirectory"作为输出目录。</p></div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="delegation"></a>16.2.&nbsp;委托（Delegation）</h2></div>
        </div>
        <div></div>
    </div>
    <p> 委托是用来在流程执行过程中包含用户定制代码的一种机制。</p>

    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="thejbpmclassloader"></a>16.2.1.&nbsp;jBPM的类载入器</h3></div>
            </div>
            <div></div>
        </div>
        <p> jBPM类载入器是载入jBPM的类。也就是说，这个类载入器的类搜索路径中有jBMP的核心库文件<tt class="literal">jbpm-3.x.jar</tt>
            。为了使类对jBPM类载入器可见，把类放到jar文件中，然后和<tt class="literal">jbpm-3.x.jar</tt>放到一起。
            例如，对于web应用，放在WEB-INF/lib目录下。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="theprocessclassloader"></a>16.2.2.&nbsp;流程的类载入器</h3>
                </div>
            </div>
            <div></div>
        </div>
        <p> 委托类是由载入各个流程定义的类载入器载入的。jBPM类载入器是流程类载入器的父载入器。流程类载入器添加一个特定流程定义中
            所有的类。你可以通过把类放在流程包的<tt class="literal">/classes</tt>路径下来给流程添加类。注意这只是当你想要控制
            添加到流程定义中的类的版本的时候有用。如果不需要进行版本控制，使类对jBPM类载入器可见，由其来载入这些类会效率高的多。</p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="configurationofdelegations"></a>16.2.3.&nbsp;委托的配置</h3></div>
            </div>
            <div></div>
        </div>
        <p> 委托类包含了流程执行过程中可以调用的用户代码。最普通的一个例子就是动作（action）。在action的情况下，一个实现了
            <tt class="literal">ActionHandler</tt>接口的类可以在流程事件中调用。委托类是在<tt class="literal">processdefinition.xml</tt>
            中指定的。指定委托类的时候可以提供3块数据： </p>

        <div class="itemizedlist">
            <ul type="disc">
                <li>1) 类名称（必须）：委托类的全限定名称。
                </li>
                <li>2) 配置类型（可选）：指定实例化和配置委托类的方法。缺省情况下，会直接调用委托类的缺省构造器并忽略配置信息。</li>
                <li>3) 配置（可选）：委托类对象的配置，按照配置类型规定的格式提供。
                </li>
            </ul>
        </div>
        <p>以下说明所有配置类型：</p>

        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="configtypefield"></a>16.2.3.1.&nbsp;config-type field</h4></div>
                </div>
                <div></div>
            </div>
            <p> 这是缺省的配置类型。<tt class="literal">config-type field</tt>类型会首先实例化一个委托类的对象，然后根据配置中
                指定的值来设置对象的属性。配置是一个xml文件，元素名称必须和类的属性名称一致。每个配置元素中的文本会作为值放到对应的类
                属性中。如果需要并可能，这些文本内容会转换成类属性的类型。
            </p>

            <p>支持的转换类型：</p>

            <div class="itemizedlist">
                <ul type="disc">
                    <li>字符串当然不需要进行转换，但是会被去掉前面和后面的空格。
                    </li>
                    <li>原生类型如 int, long, float, double, ...
                    </li>
                    <li>以及原生类型的基本包装类。
                    </li>
                    <li>lists, sets 和 collections. 在这种情况下，xml元素的内容应该也是一个元素的集合，每个元素会被解释，
                        然后递归地应用转换。如果元素的类型与<tt class="literal">java.lang.String</tt>，可以通过指定一个
                        类型属性来指明类型，使用类的全限定名。例如，如下的片段会注入一个字符串的ArrayList到'numbers'属性：
	        <pre class="programlisting">&lt;numbers&gt;
  &lt;element&gt;one&lt;/element&gt;
  &lt;element&gt;two&lt;/element&gt;
  &lt;element&gt;three&lt;/element&gt;
&lt;/numbers&gt;</pre>
                        <p> xml元素的文本内容可以被转换成任何有一个字符串参数构造器的对象。如果要用其他类型而不是字符串，在元素的属性中指定
                            <tt class="literal">element-type</tt>（在这个例子中是'numbers'）。
                        </p>

                        <p>这是一个map的例子:
                        </p><pre class="programlisting">&lt;numbers&gt;
  &lt;entry&gt;&lt;key&gt;one&lt;/key&gt;&lt;value&gt;1&lt;/value&gt;&lt;/entry&gt;
  &lt;entry&gt;&lt;key&gt;two&lt;/key&gt;&lt;value&gt;2&lt;/value&gt;&lt;/entry&gt;
  &lt;entry&gt;&lt;key&gt;three&lt;/key&gt;&lt;value&gt;3&lt;/value&gt;&lt;/entry&gt;
&lt;/numbers&gt;</pre>
                    </li>
                    <li>maps. 这种情况下，属性元素下的每个子元素都是<tt class="literal">key</tt>元素和<tt class="literal">value</tt>元素.
                        key元素和和属性元素都是递归地应用转换规则来解释的。跟collection一样，如果没有指定<tt class="literal">type</tt>属性，
                        就假定为<tt class="literal">java.lang.String</tt>类型。
                    </li>
                    <li>org.dom4j.Element
                    </li>
                    <li>其他任何类型，使用类的字符串构造器。
                    </li>
                </ul>
            </div>
            <p>例如在如下的类中...</p>
            <pre class="programlisting">public class MyAction implements ActionHandler {
  // access specifiers can be private, default, protected or public
  private String city;
  Integer rounds;
  ...
}</pre>
            <p>...这是一个有效的配置:</p><pre class="programlisting">...
&lt;action class="org.test.MyAction"&gt;
  &lt;city&gt;Atlanta&lt;/city&gt;
  &lt;rounds&gt;5&lt;/rounds&gt;
&lt;/action&gt;
...</pre>
        </div>
        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="configtypebean"></a>16.2.3.2.&nbsp;config-type bean</h4></div>
                </div>
                <div></div>
            </div>
            <p> 和<tt class="literal">config-type field</tt>一样，但属性是通过setter方法来设置的，而不是直接到属性。应用
                同样的转换。</p></div>
        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="configtypeconstructor"></a>16.2.3.3.&nbsp;config-type constructor
                    </h4></div>
                </div>
                <div></div>
            </div>
            <p> 这种实例化会把整个属性元素的文本内容传入委托类的构造器，然后在构造器中处理这些文本。</p></div>
        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="configtypeconfigurationproperty"></a>16.2.3.4.&nbsp;config-type
                        configuration-property</h4></div>
                </div>
                <div></div>
            </div>
            <p> 首先，实例化的时候会调用类的缺省构造器，然后会把完整的xml元素的内容作为文本传递到方法<tt class="literal">void configure(String);</tt>
                中（跟jBPM 2中一样）。</p></div>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="expressions"></a>16.3.&nbsp;表达式（Expressions）</h2></div>
        </div>
        <div></div>
    </div>
    <p> 某些委托类对类似JSP/JSF EL方式的表达式语言有支持。在action, assignment和decision condition中，你可以编写表达式如：
        <tt class="literal">expression="#{myVar.handler[assignments].assign}"</tt>
    </p>

    <p>关于这些表达式语言的基础可以看
        <a href="http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JSPIntro7.html" target="_top">走进 J2EE
            教程</a>.
    </p>

    <p> jPDL表达式语言与JSF表达式语言相似。这意味着jPDL EL是基于JSP EL的，但是使用<tt class="literal">#{...}</tt>
        表示，以及包括了对方法绑定的支持。
    </p>

    <p> 依据上下文，流程变量或任务实例变量可以以以下内置对象为开始：
    </p>

    <div class="itemizedlist">
        <ul type="disc">
            <li>taskInstance (org.jbpm.taskmgmt.exe.TaskInstance)</li>
            <li>processInstance (org.jbpm.graph.exe.ProcessInstance)</li>
            <li>processDefinition (org.jbpm.graph.def.ProcessDefinition)</li>
            <li>token (org.jbpm.graph.exe.Token)</li>
            <li>taskMgmtInstance (org.jbpm.taskmgmt.exe.TaskMgmtInstance)</li>
            <li>contextInstance (org.jbpm.context.exe.ContextInstance)</li>
        </ul>
    </div>
    <p> 在JBoss SEAM环境中，这个特性变得真正强大起来。因为jBPM和
        <a href="http://www.jboss.com/products/seam" target="_top">JBoss SEAM</a>
        的整合，所有你的后端bean,EJB和其他<tt class="literal">任何东西（one-kind-of-stuff）</tt>
        都变成可以在流程定义中使用了。这要多谢Gavin！
    </p></div>
<div class="section" lang="cn">
<div class="titlepage">
    <div>
        <div><h2 class="title" style="clear: both"><a name="d0e4577"></a>16.4.&nbsp;jPDL 的 xml 模式（schema）</h2></div>
    </div>
    <div></div>
</div>
<p>jPDL模式是用在流程包的<tt class="literal">processdefinition.xml</tt>文件中的xml元素定义文件（类似DTD）。</p>

<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="processdefinition.validation"></a>16.4.1.&nbsp;校验（Validation）</h3></div>
        </div>
        <div></div>
    </div>
    <p> 当解释jPDL的XML文档时，jBPM会先用jPDL模式来校验。不过要满足两个条件：第一XML文件中有参考到jPDL的模式文件，例如
    </p><pre class="programlisting">&lt;process-definition xmlns="urn:jbpm.org:jpdl-3.1"&gt;
  ...
&lt;/process-definition&gt;</pre>
    <p>第二，xerces解释器要在类路径中。</p>

    <p>jPDL的schema可以从 <tt
            class="literal">${jbpm.home}/src/java.jbpm/org/jbpm/jpdl/xml/jpdl-3.1.xsd</tt>
        或 <a href="http://jbpm.org/jpdl-3.1.xsd" target="_top">http://jbpm.org/jpdl-3.1.xsd</a>找到.
    </p></div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="processdefinition.element"></a>16.4.2.&nbsp;process-definition</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="process.definition.schema"></a>

        <p class="title"><b>Table&nbsp;16.1.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>流程名称</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#swimlane.element" title="16.4.25.&nbsp;swimlane">swimlane</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>流程中用到的泳道。泳道表示流程角色，在指派（assignment）中使用。
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#startstate.element" title="16.4.5.&nbsp;start-state">start-state</a></td>
                    <td>属性</td>
                    <td>[0..1]</td>
                    <td>流程的开始状态节点。注意一个流程没有start-state是可以的，但是无法被执行。
                    </td>
                </tr>
                <tr>
                    <td>{<a href="jpdl.html#endstate.element" title="16.4.6.&nbsp;end-state">end-state</a>|<a
                            href="jpdl.html#state.element" title="16.4.7.&nbsp;state">state</a>|<a
                            href="jpdl.html#node.element" title="16.4.3.&nbsp;node">node</a>|<a
                            href="jpdl.html#tasknode.element" title="16.4.8.&nbsp;task-node">task-node</a>|<a
                            href="jpdl.html#processstate.element"
                            title="16.4.9.&nbsp;process-state">process-state</a>|<a href="jpdl.html#superstate.element"
                                                                                    title="16.4.10.&nbsp;super-state">super-state</a>|<a
                            href="jpdl.html#fork.element" title="16.4.11.&nbsp;fork">fork</a>|<a
                            href="jpdl.html#join.element" title="16.4.12.&nbsp;join">join</a>|<a
                            href="jpdl.html#decision.element" title="16.4.13.&nbsp;decision">decision</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>流程定义的节点。注意一个流程没有节点是可以的，但是无法被执行。
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#event.element" title="16.4.14.&nbsp;event">event</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>流程事件（event）当作是动作（action）的容器使用。</td>
                </tr>
                <tr>
                    <td>{<a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a>|<a
                            href="jpdl.html#script.element" title="16.4.17.&nbsp;script">script</a>|<a
                            href="jpdl.html#create.timer.element" title="16.4.22.&nbsp;create-timer">create-timer</a>|<a
                            href="jpdl.html#cancel.timer.element" title="16.4.23.&nbsp;cancel-timer">cancel-timer</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>全局定义的action，可以被从event和transition中引用。注意这些action必须指定一个名字以便能被引用到。
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#task.element" title="16.4.24.&nbsp;task">task</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>全局定义的task，用法跟action一样</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>一个例外处理类的类表，应用在所有流程定义的委托类在流程执行中抛出的例外。
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="node.element"></a>16.4.3.&nbsp;node</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="node.schema"></a>

        <p class="title"><b>Table&nbsp;16.2.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>{<a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a>|<a
                            href="jpdl.html#script.element" title="16.4.17.&nbsp;script">script</a>|<a
                            href="jpdl.html#create.timer.element" title="16.4.22.&nbsp;create-timer">create-timer</a>|<a
                            href="jpdl.html#cancel.timer.element" title="16.4.23.&nbsp;cancel-timer">cancel-timer</a>}
                    </td>
                    <td>元素</td>
                    <td>1</td>
                    <td>用户定制action,表示本节点的行为</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="common.node.elements"></a>16.4.4.&nbsp;普通节点元素</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="common.node.schema"></a>

        <p class="title"><b>Table&nbsp;16.3.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>节点名称</td>
                </tr>
                <tr>
                    <td>async</td>
                    <td>属性</td>
                    <td>{ true | false }, 缺省是false</td>
                    <td>如果为true，这个节点会被异步执行。
                        参看 <a href="asynchronouscontinuations.html"
                                    title="Chapter&nbsp;13.&nbsp;Asynchronous continuations">Chapter&nbsp;13, <i>异步续前（Asynchronous
                        continuations）</i></a></td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#transition.element" title="16.4.15.&nbsp;transition">transition</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>离开节点的transition。 每个离开节点的transition都必须有一个唯一的名称。最后一个transition可以允许
                        没有名称。第一个transition是缺省transition，但没有指定离开的transition的时候，使用缺省的。
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#event.element" title="16.4.14.&nbsp;event">event</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>支持的event类型： {node-enter|node-leave}</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>一个例外处理类的列表，引用在所有流程节点的委托类中抛出的异常中。
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#timer.element" title="16.4.21.&nbsp;timer">timer</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>指定一个监控节点中执行的期间的定时器。</td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="startstate.element"></a>16.4.5.&nbsp;start-state</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="start.state.schema"></a>

        <p class="title"><b>Table&nbsp;16.4.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>节点名称</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#task.element" title="16.4.24.&nbsp;task">task</a></td>
                    <td>元素</td>
                    <td>[0..1]</td>
                    <td>开始这个新流程实例或捕捉流程初始化的任务。参见 <a
                            href="taskmanagement.html#swimlaneinstarttask" title="11.7.&nbsp;Swimlane in start task">Section&nbsp;11.7,
                        &#8220;开始节点中的Swimlane&#8221;</a></td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#event.element" title="16.4.14.&nbsp;event">event</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>支持的event类型： {node-leave}</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#transition.element" title="16.4.15.&nbsp;transition">transition</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>节点的离开 transitions. 每个离开节点的 transition 都必须有个唯一的名字.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>一个例外处理类的列表，应用在所有流程节点的委托类抛出的异常上。
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="endstate.element"></a>16.4.6.&nbsp;end-state</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="end.state.schema"></a>

        <p class="title"><b>Table&nbsp;16.5.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>end-state节点的名称</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#event.element" title="16.4.14.&nbsp;event">event</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>支持的event类型： {node-enter}</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>一个例外处理类的列表，应用在所有流程节点的委托类抛出的异常上。
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="state.element"></a>16.4.7.&nbsp;state</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="state.schema"></a>

        <p class="title"><b>Table&nbsp;16.6.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="tasknode.element"></a>16.4.8.&nbsp;task-node</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="task.node.schema"></a>

        <p class="title"><b>Table&nbsp;16.7.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>signal</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{unsynchronized|never|first|first-wait|last|last-wait}, 缺省是
                         <tt class="literal">last</tt>. signal specifies the effect of task completion
                        on the process execution continuation.
                    </td>
                </tr>
                <tr>
                    <td>create-tasks</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{yes|no|true|false}, default is <tt class="literal">true</tt>. can be set
                        to false when a runtime calculation has to determine which of the tasks have
                        to be created. in that case, add an action on <tt class="literal">node-enter</tt>,
                        create the tasks in the action and set <tt class="literal">create-tasks</tt> to
                        <tt class="literal">false</tt>.
                    </td>
                </tr>
                <tr>
                    <td>end-tasks</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{yes|no|true|false}, default is <tt class="literal">false</tt>. In case
                        remove-tasks is set to true, on <tt class="literal">node-leave</tt>,
                        all the tasks that are still open are ended.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#task.element" title="16.4.24.&nbsp;task">task</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>the tasks that should be created when execution arrives in this task node.</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="processstate.element"></a>16.4.9.&nbsp;process-state</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="process.state.schema"></a>

        <p class="title"><b>Table&nbsp;16.8.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><a href="jpdl.html#subprocess.element" title="16.4.28.&nbsp;sub-process">sub-process</a></td>
                    <td>元素</td>
                    <td>1</td>
                    <td>the sub process that is associated with this node</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#variable.element" title="16.4.19.&nbsp;variable">variable</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>specifies how data should be copied from the super process
                        to the sub process at the start and from the sub process to the
                        super process upon completion of the sub process.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="superstate.element"></a>16.4.10.&nbsp;super-state</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="super.state.schema"></a>

        <p class="title"><b>Table&nbsp;16.9.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>{<a href="jpdl.html#endstate.element" title="16.4.6.&nbsp;end-state">end-state</a>|<a
                            href="jpdl.html#state.element" title="16.4.7.&nbsp;state">state</a>|<a
                            href="jpdl.html#node.element" title="16.4.3.&nbsp;node">node</a>|<a
                            href="jpdl.html#tasknode.element" title="16.4.8.&nbsp;task-node">task-node</a>|<a
                            href="jpdl.html#processstate.element"
                            title="16.4.9.&nbsp;process-state">process-state</a>|<a href="jpdl.html#superstate.element"
                                                                                    title="16.4.10.&nbsp;super-state">super-state</a>|<a
                            href="jpdl.html#fork.element" title="16.4.11.&nbsp;fork">fork</a>|<a
                            href="jpdl.html#join.element" title="16.4.12.&nbsp;join">join</a>|<a
                            href="jpdl.html#decision.element" title="16.4.13.&nbsp;decision">decision</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>the nodes of the superstate. superstates can be nested.</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="fork.element"></a>16.4.11.&nbsp;fork</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="fork.schema"></a>

        <p class="title"><b>Table&nbsp;16.10.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="join.element"></a>16.4.12.&nbsp;join</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="join.schema"></a>

        <p class="title"><b>Table&nbsp;16.11.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="decision.element"></a>16.4.13.&nbsp;decision</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="decision.schema"></a>

        <p class="title"><b>Table&nbsp;16.12.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><a href="jpdl.html#handler.element" title="16.4.20.&nbsp;handler">handler</a></td>
                    <td>元素</td>
                    <td>either a 'handler' element or conditions on the transitions should be specified</td>
                    <td>the name of a <tt class="literal">org.jbpm.jpdl.Def.DecisionHandler</tt> implementation</td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#transition.element" title="16.4.15.&nbsp;transition">transition</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>the leaving transitions. The leaving transitions of a
                        decision can be extended with a condition. The decision will look
                        for the first transition for which the condition evaluates to true.
                        A transition without a condition is considered to evaluate to true
                        (to model the 'otherwise' branch). See
                        <a href="jpdl.html#condition.element" title="16.4.29.&nbsp;condition">the condition element</a>
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                    <td>&nbsp;</td>
                    <td>&nbsp;</td>
                    <td>参看 <a href="jpdl.html#common.node.elements" title="16.4.4.&nbsp;普通节点元素">普通节点元素</a></td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="event.element"></a>16.4.14.&nbsp;event</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="event.schema"></a>

        <p class="title"><b>Table&nbsp;16.13.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>type</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the event type that is expressed relative to the element
                        on which the event is placed
                    </td>
                </tr>
                <tr>
                    <td>{<a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a>|<a
                            href="jpdl.html#script.element" title="16.4.17.&nbsp;script">script</a>|<a
                            href="jpdl.html#create.timer.element" title="16.4.22.&nbsp;create-timer">create-timer</a>|<a
                            href="jpdl.html#cancel.timer.element" title="16.4.23.&nbsp;cancel-timer">cancel-timer</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>the list of actions that should be executed on this event</td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="transition.element"></a>16.4.15.&nbsp;transition</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="transition.schema"></a>

        <p class="title"><b>Table&nbsp;16.14.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the transition. Note that each transition leaving a
                        node *must* have a distinct name.
                    </td>
                </tr>
                <tr>
                    <td>to</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the hierarchical name of the destination node. For more information about hierarchical
                        names, see <a href="processmodelling.html#hierarchicalnames"
                                      title="9.6.3.&nbsp;Hierarchical names">Section&nbsp;9.6.3, &#8220;Hierarchical
                        names&#8221;</a></td>
                </tr>
                <tr>
                    <td>{<a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a>|<a
                            href="jpdl.html#script.element" title="16.4.17.&nbsp;script">script</a>|<a
                            href="jpdl.html#create.timer.element" title="16.4.22.&nbsp;create-timer">create-timer</a>|<a
                            href="jpdl.html#cancel.timer.element" title="16.4.23.&nbsp;cancel-timer">cancel-timer</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>the actions to be executed upon taking this transition. Note that the
                        actions of a transition do not need to be put in an event (because there is
                        only one)
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>a list of exception handlers that applies to all
                        exceptions thrown by delegation classes thrown in this process node.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="action.element"></a>16.4.16.&nbsp;action</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="action.schema"></a>

        <p class="title"><b>Table&nbsp;16.15.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the action. When actions are given names, they can be
                        looked up from the process definition. This can be useful for runtime
                        actions and declaring actions only once.
                    </td>
                </tr>
                <tr>
                    <td>class</td>
                    <td>attibute</td>
                    <td>either, a ref-name or an expression</td>
                    <td>the fully qualified class name of the class that implements the
                        <tt class="literal">org.jbpm.graph.def.ActionHandler</tt> interface.
                    </td>
                </tr>
                <tr>
                    <td>ref-name</td>
                    <td>attibute</td>
                    <td>either this or class</td>
                    <td>the name of the referenced action. The content of this action is
                        not processed further if a referenced action is specified.
                    </td>
                </tr>
                <tr>
                    <td>expression</td>
                    <td>attibute</td>
                    <td>either this, a class or a ref-name</td>
                    <td>A jPDL expression that resolves to a method. See also <a href="jpdl.html#expressions"
                                                                                 title="16.3.&nbsp;Expressions">Section&nbsp;16.3,
                        &#8220;Expressions&#8221;</a></td>
                </tr>
                <tr>
                    <td>accept-propagated-events</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{yes|no|true|false}. Default is yes|true. If set to false, the action
                        will only be executed on events that were fired on this action's element.
                        for more information, see <a href="processmodelling.html#eventpropagation"
                                                     title="9.5.4.&nbsp;Event propagation">Section&nbsp;9.5.4, &#8220;Event
                        propagation&#8221;</a></td>
                </tr>
                <tr>
                    <td>config-type</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{<a href="jpdl.html#configtypefield" title="16.2.3.1.&nbsp;config-type field">field</a>|<a
                            href="jpdl.html#configtypebean" title="16.2.3.2.&nbsp;config-type bean">bean</a>|<a
                            href="jpdl.html#configtypeconstructor" title="16.2.3.3.&nbsp;config-type constructor">constructor</a>|<a
                            href="jpdl.html#configtypeconfigurationproperty"
                            title="16.2.3.4.&nbsp;config-type configuration-property">configuration-property</a>}.
                        Specifies how the action-object should be constructed and how the content of this element should
                        be used as configuration information for that action-object.
                    </td>
                </tr>
                <tr>
                    <td>async</td>
                    <td>attibute</td>
                    <td>{true|false}</td>
                    <td>Default is false, which means that the action is executed in the thread of the
                        execution. If set to true, a message will be sent to the command executor and that
                        component will execute the action asynchonously in a separate transaction.
                    </td>
                </tr>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content}</td>
                    <td>可选</td>
                    <td>the content of the action can be used as configuration information
                        for your custom action implementations. This allows the creation of reusable
                        delegation classes. For more about delegation configuration, see
                        <a href="jpdl.html#configurationofdelegations"
                           title="16.2.3.&nbsp;Configuration of delegations">Section&nbsp;16.2.3, &#8220;Configuration
                            of delegations&#8221;</a>.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="script.element"></a>16.4.17.&nbsp;script</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="script.schema"></a>

        <p class="title"><b>Table&nbsp;16.16.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the script-action. When actions are given names, they can be
                        looked up from the process definition. This can be useful for runtime
                        actions and declaring actions only once.
                    </td>
                </tr>
                <tr>
                    <td>accept-propagated-events</td>
                    <td>属性</td>
                    <td>optional [0..*]</td>
                    <td>{yes|no|true|false}. Default is yes|true. If set to false, the action
                        will only be executed on events that were fired on this action's element.
                        for more information, see <a href="processmodelling.html#eventpropagation"
                                                     title="9.5.4.&nbsp;Event propagation">Section&nbsp;9.5.4, &#8220;Event
                        propagation&#8221;</a></td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#expression.element" title="16.4.18.&nbsp;expression">expression</a></td>
                    <td>元素</td>
                    <td>[0..1]</td>
                    <td>the beanshell script. If you don't specify <a href="jpdl.html#variable.element"
                                                                      title="16.4.19.&nbsp;variable">variable</a>
                        elements, you can write the expression as the content
                        of the script element (omitting the expression element tag).
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#variable.element" title="16.4.19.&nbsp;variable">variable</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>in variable for the script. If no in variables are specified, all the
                        variables of the current token will be loaded into the script evaluation.
                        Use the in variables if you want to limit the number of variables loaded into
                        the script evaluation.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="expression.element"></a>16.4.18.&nbsp;expression</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="expression.schema"></a>

        <p class="title"><b>Table&nbsp;16.17.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content}</td>
                    <td>&nbsp;</td>
                    <td>a bean shell script.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="variable.element"></a>16.4.19.&nbsp;variable</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="variable.schema"></a>

        <p class="title"><b>Table&nbsp;16.18.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the process variable name</td>
                </tr>
                <tr>
                    <td>access</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>default is <tt class="literal">read,write</tt>. It is a comma
                        separated list of access specifiers. The only access specifiers
                        used so far are <tt class="literal">read</tt>, <tt class="literal">write</tt>
                        and <tt class="literal">required</tt>.
                    </td>
                </tr>
                <tr>
                    <td>mapped-name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>this defaults to the variable name. it specifies a name to
                        which the variable name is mapped. the meaning of the mapped-name is
                        dependent on the context in which this element is used. for a script,
                        this will be the script-variable-name. for a task controller, this will
                        be the label of the task form parameter and for a process-state, this
                        will be the variable name used in the sub-process.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="handler.element"></a>16.4.20.&nbsp;handler</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="handler.schema"></a>

        <p class="title"><b>Table&nbsp;16.19.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>expression</td>
                    <td>attibute</td>
                    <td>either this or a class</td>
                    <td>A jPDL expression. The returned result is transformed to a string with
                        the toString() method. The resulting string should match one of the leaving
                        transitions. See also <a href="jpdl.html#expressions" title="16.3.&nbsp;Expressions">Section&nbsp;16.3,
                        &#8220;Expressions&#8221;</a>.
                    </td>
                </tr>
                <tr>
                    <td>class</td>
                    <td>attibute</td>
                    <td>either this or ref-name</td>
                    <td>the fully qualified class name of the class that implements the
                        <tt class="literal">org.jbpm.graph.node.DecisionHandler</tt> interface.
                    </td>
                </tr>
                <tr>
                    <td>config-type</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{<a href="jpdl.html#configtypefield" title="16.2.3.1.&nbsp;config-type field">field</a>|<a
                            href="jpdl.html#configtypebean" title="16.2.3.2.&nbsp;config-type bean">bean</a>|<a
                            href="jpdl.html#configtypeconstructor" title="16.2.3.3.&nbsp;config-type constructor">constructor</a>|<a
                            href="jpdl.html#configtypeconfigurationproperty"
                            title="16.2.3.4.&nbsp;config-type configuration-property">configuration-property</a>}.
                        Specifies how the action-object should be constructed and how the content of this element should
                        be used as configuration information for that action-object.
                    </td>
                </tr>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content}</td>
                    <td>可选</td>
                    <td>the content of the handler can be used as configuration information
                        for your custom handler implementations. This allows the creation of reusable
                        delegation classes. For more about delegation configuration, see
                        <a href="jpdl.html#configurationofdelegations"
                           title="16.2.3.&nbsp;Configuration of delegations">Section&nbsp;16.2.3, &#8220;Configuration
                            of delegations&#8221;</a>.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="timer.element"></a>16.4.21.&nbsp;timer</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="timer.schema"></a>

        <p class="title"><b>Table&nbsp;16.20.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the timer. If no name is specified, the name of the
                        enclosing node is taken. Note that every timer should have a unique name.
                    </td>
                </tr>
                <tr>
                    <td>duedate</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the duration (optionally expressed in business hours) that specifies
                        the time period between the creation of the timer and the execution of the timer.
                        参看 <a href="businesscalendar.html#duration" title="14.1.&nbsp;Duration">Section&nbsp;14.1,
                        &#8220;Duration&#8221;</a> for the syntax.
                    </td>
                </tr>
                <tr>
                    <td>repeat</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{duration | 'yes' | 'true'}after a timer has been executed on the duedate, 'repeat' optionally
                        specifies duration between repeating timer executions until the node is left.
                        If <tt class="literal">yes</tt> or <tt class="literal">true</tt> is specified, the same duration
                        as for the due date is taken for the repeat. 参看 <a href="businesscalendar.html#duration"
                                                                            title="14.1.&nbsp;Duration">Section&nbsp;14.1,
                        &#8220;Duration&#8221;</a> for the
                        syntax.
                    </td>
                </tr>
                <tr>
                    <td>transition</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>a transition-name to be taken when the timer executes, after firing
                        the timer event and executing the action (if any).
                    </td>
                </tr>
                <tr>
                    <td>cancel-event</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>this attribute is only to be used in timers of tasks. it specifies the
                        event on which the timer should be cancelled. by default, this is the
                        <tt class="literal">task-end</tt> event, but it can be set to e.g.
                        <tt class="literal">task-assign</tt> or <tt class="literal">task-start</tt>.
                        The <tt class="literal">cancel-event</tt> types can be combined by specifying them in a
                        comma separated list in the attribute.
                    </td>
                </tr>
                <tr>
                    <td>{<a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a>|<a
                            href="jpdl.html#script.element" title="16.4.17.&nbsp;script">script</a>|<a
                            href="jpdl.html#create.timer.element" title="16.4.22.&nbsp;create-timer">create-timer</a>|<a
                            href="jpdl.html#cancel.timer.element" title="16.4.23.&nbsp;cancel-timer">cancel-timer</a>}
                    </td>
                    <td>元素</td>
                    <td>[0..1]</td>
                    <td>an action that should be executed when this timer fires</td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="create.timer.element"></a>16.4.22.&nbsp;create-timer</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="create.timer.schema"></a>

        <p class="title"><b>Table&nbsp;16.21.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the timer. The name can be used for cancelling the timer
                        with a cancel-timer action.
                    </td>
                </tr>
                <tr>
                    <td>duedate</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the duration (optionally expressed in business hours) that specifies the
                        the time period between the creation of the timer and the execution of the timer.
                        参看 <a href="businesscalendar.html#duration" title="14.1.&nbsp;Duration">Section&nbsp;14.1,
                        &#8220;Duration&#8221;</a> for the syntax.
                    </td>
                </tr>
                <tr>
                    <td>repeat</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{duration | 'yes' | 'true'}after a timer has been executed on the duedate, 'repeat' optionally
                        specifies duration between repeating timer executions until the node is left.
                        If <tt class="literal">yes</tt> of <tt class="literal">true</tt> is specified, the same duration
                        as for the due date is taken for the repeat. 参看 <a href="businesscalendar.html#duration"
                                                                            title="14.1.&nbsp;Duration">Section&nbsp;14.1,
                        &#8220;Duration&#8221;</a> for the
                        syntax.
                    </td>
                </tr>
                <tr>
                    <td>transition</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>a transition-name to be taken when the timer executes, after firing the
                        the timer event and executing the action (if any).
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="cancel.timer.element"></a>16.4.23.&nbsp;cancel-timer</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="cancel.timer.schema"></a>

        <p class="title"><b>Table&nbsp;16.22.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the timer to be cancelled.</td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="task.element"></a>16.4.24.&nbsp;task</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="task.schema"></a>

        <p class="title"><b>Table&nbsp;16.23.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the name of the task. Named tasks can be referenced and looked up via the
                        <tt class="literal">TaskMgmtDefinition</tt></td>
                </tr>
                <tr>
                    <td>blocking</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{yes|no|true|false}, default is false. If blocking is set to true, the node
                        cannot be left when the task is not finished. If set to false (default) a signal
                        on the token is allowed to continue execution and leave the node. The default is set
                        to false, because blocking is normally forced by the user interface.
                    </td>
                </tr>
                <tr>
                    <td>signalling</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{yes|no|true|false}, default is true. If signalling is set to false,
                        this task will never have the capability of trigering the continuation of the
                        token.
                    </td>
                </tr>
                <tr>
                    <td>duedate</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>is a duration expressed in absolute or business hours as
                        explained in <a href="businesscalendar.html" title="Chapter&nbsp;14.&nbsp;Business calendar">Chapter&nbsp;14,
                        <i>Business calendar</i></a></td>
                </tr>
                <tr>
                    <td>swimlane</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>reference to a <a href="jpdl.html#swimlane.element" title="16.4.25.&nbsp;swimlane">swimlane</a>.
                        If a swimlane
                        is specified on a task, the assignment is ignored.
                    </td>
                </tr>
                <tr>
                    <td>priority</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>one of {highest, high, normal, low, lowest}. alternatively, any integer number
                        can be specified for the priority. FYI: (highest=1, lowest=5)
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#assignment.element" title="16.4.26.&nbsp;assignment">assignment</a></td>
                    <td>元素</td>
                    <td>可选</td>
                    <td>describes a <a href="jpdl.html#delegation" title="16.2.&nbsp;Delegation">delegation</a> that
                        will assign
                        the task to an actor when the task is created.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#event.element" title="16.4.14.&nbsp;event">event</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>支持的event类型： {task-create|task-start|task-assign|task-end}. Especially
                        for the <tt class="literal">task-assign</tt> we have added a non-persisted property
                        <tt class="literal">previousActorId</tt> to the <tt class="literal">TaskInstance</tt></td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#exceptionhandler.element" title="16.4.30.&nbsp;例外处理器">例外处理器</a>
                    </td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>a list of exception handlers that applies to all
                        exceptions thrown by delegation classes thrown in this process node.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#timer.element" title="16.4.21.&nbsp;timer">timer</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>specifies a timer that monitors the duration of an execution in this task.
                        special for task timers, the <tt class="literal">cancel-event</tt> can be specified.
                        by default the <tt class="literal">cancel-event</tt> is <tt class="literal">task-end</tt>,
                        but it can be customized to e.g. <tt class="literal">task-assign</tt> or
                        <tt class="literal">task-start</tt>.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#controller.element" title="16.4.27.&nbsp;controller">controller</a></td>
                    <td>元素</td>
                    <td>[0..1]</td>
                    <td>specifies how the process variables are transformed into task
                        form parameters. the task form paramaters are used by the user interface
                        to render a task form to the user.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="swimlane.element"></a>16.4.25.&nbsp;swimlane</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="swimlane.schema"></a>

        <p class="title"><b>Table&nbsp;16.24.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the name of the swimlane. Swimlanes can be referenced and looked up via the
                        <tt class="literal">TaskMgmtDefinition</tt></td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#assignment.element" title="16.4.26.&nbsp;assignment">assignment</a></td>
                    <td>元素</td>
                    <td>[1..1]</td>
                    <td>specifies a the assignment of this swimlane. the assignment will be performed
                        when the first task instance is created in this swimlane.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="assignment.element"></a>16.4.26.&nbsp;assignment</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="assignment.schema"></a>

        <p class="title"><b>Table&nbsp;16.25.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>expression</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>For historical reasons, this attribute expression does <span class="bold"><b>not</b></span>
                        refer to <a href="jpdl.html#expressions" title="16.3.&nbsp;Expressions">the jPDL expression</a>,
                        but instead, it is
                        an assignment expression for the jBPM identity component. For
                        more information on how to write
                        jBPM identity component expressions, see <a href="taskmanagement.html#assignmentexpressions"
                                                                    title="11.11.2.&nbsp;Assignment expressions">Section&nbsp;11.11.2,
                        &#8220;Assignment expressions&#8221;</a>.
                        Note that this implementation has a dependency on the jbpm identity component.
                    </td>
                </tr>
                <tr>
                    <td>actor-id</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>An actorId. Can be used in conjunction with pooled-actors. The actor-id
                        is resolved as <a href="jpdl.html#expressions" title="16.3.&nbsp;Expressions">an expression</a>.
                        So you can refer to
                        a fixed actorId like this <tt class="literal">actor-id="bobthebuilder"</tt>. Or you can refer
                        to a property or method that returns a String like this:
                        <tt class="literal">actor-id="myVar.actorId"</tt>, which will invoke the getActorId method
                        on the task instance variable "myVar".
                    </td>
                </tr>
                <tr>
                    <td>pooled-actors</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>A comma separated list of actorIds. Can be used in conjunction
                        with actor-id. A fixed set of pooled actors can be specified like this:
                        <tt class="literal">pooled-actors="chicagobulls, pointersisters"</tt>. The
                        pooled-actors will be resolved as <a href="jpdl.html#expressions"
                                                             title="16.3.&nbsp;Expressions">an
                        expression</a>. So you can also refer to a property or method that has to
                        return, a String[], a Collection or a comma separated list of pooled actors.
                    </td>
                </tr>
                <tr>
                    <td>class</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the fully qualified classname of an implementation of
                        <tt class="literal">org.jbpm.taskmgmt.def.AssignmentHandler</tt></td>
                </tr>
                <tr>
                    <td>config-type</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{<a href="jpdl.html#configtypefield" title="16.2.3.1.&nbsp;config-type field">field</a>|<a
                            href="jpdl.html#configtypebean" title="16.2.3.2.&nbsp;config-type bean">bean</a>|<a
                            href="jpdl.html#configtypeconstructor" title="16.2.3.3.&nbsp;config-type constructor">constructor</a>|<a
                            href="jpdl.html#configtypeconfigurationproperty"
                            title="16.2.3.4.&nbsp;config-type configuration-property">configuration-property</a>}.
                        Specifies how the assignment-handler-object should be constructed and how the content of this
                        element should be used as configuration information for that assignment-handler-object.
                    </td>
                </tr>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content}</td>
                    <td>可选</td>
                    <td>the content of the assignment-element can be used as configuration information
                        for your AssignmentHandler implementations. This allows the creation of reusable
                        delegation classes. for more about delegation configuration, see
                        <a href="jpdl.html#configurationofdelegations"
                           title="16.2.3.&nbsp;Configuration of delegations">Section&nbsp;16.2.3, &#8220;Configuration
                            of delegations&#8221;</a>.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="controller.element"></a>16.4.27.&nbsp;controller</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="controller.schema"></a>

        <p class="title"><b>Table&nbsp;16.26.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>class</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the fully qualified classname of an implementation of
                        <tt class="literal">org.jbpm.taskmgmt.def.TaskControllerHandler</tt></td>
                </tr>
                <tr>
                    <td>config-type</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>{<a href="jpdl.html#configtypefield" title="16.2.3.1.&nbsp;config-type field">field</a>|<a
                            href="jpdl.html#configtypebean" title="16.2.3.2.&nbsp;config-type bean">bean</a>|<a
                            href="jpdl.html#configtypeconstructor" title="16.2.3.3.&nbsp;config-type constructor">constructor</a>|<a
                            href="jpdl.html#configtypeconfigurationproperty"
                            title="16.2.3.4.&nbsp;config-type configuration-property">configuration-property</a>}.
                        Specifies how the assignment-handler-object should be constructed and how the content of this
                        element should be used as configuration information for that assignment-handler-object.
                    </td>
                </tr>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content}</td>
                    <td>&nbsp;</td>
                    <td>either the content of the controller is the configuration
                        of the specified task controller handler (if the class attribute is
                        specified. if no task controller handler is specified, the content
                        must be a list of variable elements.
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#variable.element" title="16.4.19.&nbsp;variable">variable</a></td>
                    <td>元素</td>
                    <td>[0..*]</td>
                    <td>in case no task controller handler is specified by the class
                        attribute, the content of the controller element must be a list of
                        variables.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="subprocess.element"></a>16.4.28.&nbsp;sub-process</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="sub.process.schema"></a>

        <p class="title"><b>Table&nbsp;16.27.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>name</td>
                    <td>属性</td>
                    <td>必须</td>
                    <td>the name of the sub process. To know how you can test
                        subprocesses, see <a href="tdd.html#testingsubprocesses"
                                             title="18.3.&nbsp;Testing sub processes">Section&nbsp;18.3, &#8220;Testing
                        sub processes&#8221;</a></td>
                </tr>
                <tr>
                    <td>version</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>the version of the sub process. If no version is
                        specified, the latest version of the given process will be
                        taken.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="condition.element"></a>16.4.29.&nbsp;condition</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="condition.schema"></a>

        <p class="title"><b>Table&nbsp;16.28.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>&nbsp;</td>
                    <td>{content} or attribute expression</td>
                    <td>必须</td>
                    <td>The contents of the condition element is <a href="jpdl.html#expressions"
                                                                    title="16.3.&nbsp;Expressions">a
                        jPDL expression</a> that should evaluate to a boolean. A decision takes the
                        first transition (as ordered in the processdefinition.xml) for which the expression
                        resolves to <tt class="literal">true</tt>. If none of the conditions resolve
                        to true, the default leaving transition (== the first one) will be taken.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="exceptionhandler.element"></a>16.4.30.&nbsp;例外处理器</h3></div>
        </div>
        <div></div>
    </div>
    <div class="table"><a name="exception.handler.schema"></a>

        <p class="title"><b>Table&nbsp;16.29.&nbsp;</b></p>
        <table border="1">
            <colgroup>
                <col>
                <col>
                <col>
                <col>
            </colgroup>
            <thead>
                <tr>
                    <th align="center">名称</th>
                    <th align="center" nowrap>类型</th>
                    <th align="center" nowrap>多重性</th>
                    <th align="center">描述</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>exception-class</td>
                    <td>属性</td>
                    <td>可选</td>
                    <td>specifies the fully qualified name of the java throwable class that should match
                        this exception handler. If this attribute is not specified, it matches all exceptions
                        (<tt class="literal">java.lang.Throwable</tt>).
                    </td>
                </tr>
                <tr>
                    <td><a href="jpdl.html#action.element" title="16.4.16.&nbsp;action">action</a></td>
                    <td>元素</td>
                    <td>[1..*]</td>
                    <td>a list of actions to be executed when an exception is being handled by this
                        exception handler.
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
</div>
</div>
</div>
<div class="navfooter">
    <hr>
    <table width="100%" summary="Navigation footer">
        <tr>
            <td width="40%" align="left"><a accesskey="p" href="logging.html">Prev</a>&nbsp;</td>
            <td width="20%" align="center"><a accesskey="u" href="index.html">Up</a></td>
            <td width="40%" align="right">&nbsp;<a accesskey="n" href="security.html">Next</a></td>
        </tr>
        <tr>
            <td width="40%" align="left" valign="top">Chapter&nbsp;15.&nbsp;Logging&nbsp;</td>
            <td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
            <td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;17.&nbsp;Security</td>
        </tr>
    </table>
</div>
</body>
</html>